home *** CD-ROM | disk | FTP | other *** search
/ User's Choice Windows CD / User's Choice Windows CD (CMS Software)(1993).iso / win_q_t / sabdu201.zip / SABDU001.TXT < prev    next >
Text File  |  1992-11-01  |  65KB  |  1,862 lines

  1. >>SABDU001
  2. ------------------ SABDU001.DLL API: OverView ------------------------
  3.  
  4.             Dynamic Load Library Routines
  5.  
  6. The SABDU001 Dynameic Load Library contains a set of routines for
  7. creating and manipulating diskette type objects.  The sets of routines
  8. are:
  9.     DiskDrive               This are the ones that are usually used.
  10.                             They operate at the logical level.
  11.  
  12.     DDrive                  Drive object
  13.     FDrive                  File object
  14.     MDrive                  Memory object
  15.     VDrive                  Virtual object
  16.  
  17.     DebugOut                Debugging routines
  18.  
  19.     HandleStatus            Callback routine used to communicate
  20.                             progress during long running operations
  21.                             (i.e. formatting a diskette) and status.
  22. >>DDrive
  23. ------------------ SABDU001.DLL API: DDrive objects ------------------
  24.  
  25.  A DDrive (Diskette Drive) is a specialized version of the VDrive
  26.  (Virtual Drive).  It is an object that represents a physical drive.
  27.  
  28.  The following functions are available to manipulate it:
  29.      DDriveCreate        Creates a DDrive object
  30.      DDriveDelete        Deletes a DDrive object
  31.      DDriveFormatTrack   Formats a track
  32.      DDriveForceReset    Issues a reset to the drive
  33.      DDriveReadSectors   Reads a group of sectors from the drive
  34.      DDriveReset         Issues a reset to the drive if it was used
  35.      DDriveSetRead       Sets up for reading from the drive
  36.      DDriveSetWrite      Sets up for writing to the drive
  37.      DDriveWriteSectors  Writes a group of sectors to the drive
  38. >>DDriveCreate
  39. ------------------ SABDU001.DLL API: DDriveCreate --------------------
  40.  
  41.  VOID far * FAR PASCAL DDriveCreate (
  42.                                      char cDrive
  43.                                     )
  44.  
  45.  Creates a DDrive object associated with drive cDrive and returns a
  46.  pointer to it.
  47.  
  48.  Example:
  49.          VOID far *pDriveA ;
  50.  
  51.          pDriveA = DDriveCreate ( 'A' ) ;
  52. >>DDriveDelete
  53. ------------------ SABDU001.DLL API: DDriveDelete --------------------
  54.  
  55.  VOID       FAR PASCAL DDriveDelete (
  56.                                      pDDrive
  57.                                     )
  58.  
  59.  Deletes the DDrive object pointed to by pDDrive.
  60.  
  61.  Example:
  62.          VOID far *pDriveA ;
  63.  
  64.          pDriveA = DDriveCreate ( 'A' ) ;
  65.          ...
  66.          DDriveDelete ( pDriveA ) ;
  67.          pDriveA = NULL ;
  68. >>DDriveSetRead
  69. ------------------ SABDU001.DLL API: DDriveSetRead -------------------
  70.  
  71.  UINT       FAR PASCAL DDriveSetRead (
  72.                                       VOID far *pDDrive,
  73.                                       UINT nTempType,
  74.                                       UINT nCylinders
  75.                                      )
  76.  
  77.  Prepares the DDrive object pointed to by pDDrive for reading.
  78.  
  79.  nTempType defines the type of diskette expected:
  80.            FD0360 FD0720 FD1200 FD1440 FD2880
  81.  
  82.  nCylinders defines the number of cylinders.
  83.  
  84.  Example:
  85.          VOID far *pDriveA ;
  86.  
  87.          pDriveA = DDriveCreate ( 'A' ) ;
  88.          ...
  89.          DDriveSetRead ( pDriveA, FD0360, NULL ) ;
  90. >>DDriveSetWrite
  91. ------------------ SABDU001.DLL API: DDriveSetWrite ------------------
  92.  
  93.  UINT       FAR PASCAL DDriveSetWrite (
  94.                                        VOID far *pDDrive,
  95.                                        UINT nTempType,
  96.                                        UINT nCylinders
  97.                                       )
  98.  
  99.  Prepares the DDrive object pointed to by pDDrive for writing.
  100.  
  101.  nTempType defines the type of diskette expected:
  102.            FD0360 FD0720 FD1200 FD1440 FD2880
  103.  
  104.  nCylinders defines the number of cylinders.
  105.  
  106.  Example:
  107.          VOID far *pDriveA ;
  108.  
  109.          pDriveA = DDriveCreate ( 'A' ) ;
  110.          ...
  111.          DDriveSetWrite ( pDriveA, FD0360, NULL ) ;
  112. >>DDriveReset
  113. ------------------ SABDU001.DLL API: DDriveReset ---------------------
  114.  
  115.  UINT       FAR PASCAL DDriveReset (
  116.                                     VOID far *pDDrive
  117.                                    )
  118.  
  119.  Resets the DDrive object pointed to by pDDrive.
  120.  
  121.  Example:
  122.          VOID far *pDriveA ;
  123.  
  124.          pDriveA = DDriveCreate ( 'A' ) ;
  125.          ...
  126.          DDriveReset ( pDriveA ) ;
  127. >>DDriveForceReset
  128. ------------------ SABDU001.DLL API: DDriveForceReset ----------------
  129.  
  130.  UINT       FAR PASCAL DDriveForceReset (
  131.                                          VOID far *pDDrive
  132.                                         )
  133.  
  134.  Resets the DDrive object pointed to by pDDrive.
  135.  
  136.  Example:
  137.          VOID far *pDriveA ;
  138.  
  139.          pDriveA = DDriveCreate ( 'A' ) ;
  140.          ...
  141.          DDriveForceReset ( pDriveA ) ;
  142. >>DDriveFormatTrack
  143. ------------------ SABDU001.DLL API: DDriveFormatTrack ---------------
  144.  
  145.  UINT       FAR PASCAL DDriveForceReset (
  146.                                          VOID far *pDDrive,
  147.                                          UNIT nCylinder,
  148.                                          UNIT nHead
  149.                                         )
  150.  
  151.  Formats the track pointed to by DDrive object pointer
  152.  
  153.  Example:
  154.          VOID far *pDriveA ;
  155.  
  156.          pDriveA = DDriveCreate ( pDriveA ) ;
  157.          ...
  158.          DDriveFormatTrack ( pDriveA, nCylinder, nHead ) ;
  159. >>DDriveReadSectors
  160. ------------------ SABDU001.DLL API: DDriveReadSectors ---------------
  161.  
  162.  UINT       FAR PASCAL DDriveReadSectors (
  163.                                           VOID far *pDDrive,
  164.                                           UNIT nCylinder,
  165.                                           UNIT nHead,
  166.                                           UINT nSector,
  167.                                           UINT nCount,
  168.                                           LPBYTE lpcBuffer
  169.                                          )
  170.  
  171.  Reads a group of sectors from the drive pointerd to by pDDrive
  172.  
  173.  nCylinder     Cylinder to read from
  174.  nHead         Head to read with
  175.  nSector       Starting sector
  176.  nCount        Number of sectors to read
  177.  lpcBuffer     Buffer to contain the data read.
  178.  
  179.  Example:
  180.          VOID far *pDriveA ;
  181.  
  182.          pDriveA = DDriveCreate ( pDriveA ) ;
  183.          ...
  184.          DDriveReadSectors ( pDriveA, nCylinder, nHead, nSector,
  185.                              nCount, lpcBuffer ) ;
  186. >>DDriveWriteSectors
  187. ------------------ SABDU001.DLL API: DDriveWriteSectors --------------
  188.  
  189.  UINT       FAR PASCAL DDriveWriteSectors (
  190.                                            VOID far *pDDrive,
  191.                                            UNIT nCylinder,
  192.                                            UNIT nHead,
  193.                                            UINT nSector,
  194.                                            UINT nCount,
  195.                                            LPBYTE lpcBuffer
  196.                                           )
  197.  
  198.  Writes a group of sectors from the drive pointerd to by pDDrive
  199.  
  200.  nCylinder     Cylinder to read from
  201.  nHead         Head to read with
  202.  nSector       Starting sector
  203.  nCount        Number of sectors to read
  204.  lpcBuffer     Buffer to contain the data read.
  205.  
  206.  Example:
  207.          VOID far *pDriveA ;
  208.  
  209.          pDriveA = DDriveCreate ( pDriveA ) ;
  210.          ...
  211.          DDriveWriteSectors ( pDriveA, nCylinder, nHead, nSector,
  212.                               nCount, lpcBuffer ) ;
  213. >>DebugOut
  214. ------------------ SABDU001.DLL API: DebugOut objects ----------------
  215.  
  216.  A DebugOut object is a debugging aid:
  217.  
  218.  The following functions are available to manipulate it:
  219.      DebugOutCreate        Creates debug object
  220.      DebugOutOutputIf      Outputs a message
  221.      DebugOutScan          Scans command line for control information
  222.      DebugOutczDebugBuffer Returns pointer to debug buffer
  223. >>DebugOutCreate
  224. ------------------ SABDU001.DLL API: DebugOutCreate ------------------
  225.  
  226. VOID far * FAR PASCAL CEXPORT DebugOutCreate (
  227.                                               LPCSTR lpczCmdLine
  228.                                              ) ;
  229.  
  230.   Command line:
  231.                [/Dxxxxxxxx [/Myyyyyyyy] [/Ffilename]]
  232.  
  233.   xxxxxxxx is a hex string each bit of which can be used to control
  234.            the sending of trace messages
  235.  
  236.   yyyyyyyy is a hex string each bit of which indicates if a control
  237.            message should be displayed in a MessageBox
  238.  
  239.   filename trace file name
  240.  
  241.   Returns a pointer to a debug object.
  242.  
  243. >>DebugOutScan
  244. ------------------ SABDU001.DLL API: DebugOutScan --------------------
  245.  
  246. VOID       FAR PASCAL CEXPORT DebugOutScan   (
  247.                                               LPCSTR lpczCmdLine
  248.                                              ) ;
  249.  
  250.   Command line:
  251.                [/Dxxxxxxxx [/Myyyyyyyy] [/Ffilename]]
  252.  
  253.   xxxxxxxx is a hex string each bit of which can be used to control
  254.            the sending of trace messages
  255.  
  256.   yyyyyyyy is a hex string each bit of which indicates if a control
  257.            message should be displayed in a MessageBox
  258.  
  259.   filename trace file name
  260.  
  261. >>DebugOutOutputIf
  262. ------------------ SABDU001.DLL API: DebugOutOutputIf ----------------
  263.  
  264. VOID       FAR PASCAL CEXPORT DebugOutOutputIf (
  265.                                                 unsigned long ulDFlag,
  266.                                                 LPCSTR lpczText,
  267.                                                 LPCSTR lpczTitle,
  268.                                                 UINT nMFlags
  269.                                                ) ;
  270.  
  271.   ulDFlag is matched with /D and /M from command line to determine if
  272.   message should be output to trace or displayed in a MessageBox.
  273.  
  274.   lpczText  pointer to text of trace message
  275.   lpczTitle pointer to title of trace message
  276.   nMFlags   MessageBox flags
  277.  
  278. >>DebugOutczDebugBuffer
  279. ------------------ SABDU001.DLL API: DebugOutczDebugBuffer -----------
  280.  
  281. char far * FAR PASCAL CEXPORT DebugOutczDebugBuffer (
  282.                                                      VOID
  283.                                                     ) ;
  284.  
  285.   Returns pointer to debug buffer that can be used to format messages.
  286.  
  287. >>DiskDrive
  288. ------------------ SABDU001.DLL API: DiskDrive objects ---------------
  289.  
  290.  A DiskDrive is a wrapper that encapsolates a virtual (VDrive) object
  291.  and provides all of the functions needed to manipulate it
  292.  
  293.  The following functions are available to manipulate it:
  294.      DiskDriveCompare              Compares two DiskDrive objects
  295.      DiskDriveCopy                 Copies a DiskDrive object
  296.      DiskDriveCreateDrive          Creates a DiskDrive object
  297.      DiskDriveCreateFile           Creates a DiskDrive object
  298.      DiskDriveCreateMemory         Creates a DiskDrive object
  299.      DiskDriveCreateVDrive         Creates a DiskDrive object
  300.      DiskDriveDelete               Deletes a DiskDrive object
  301.      DiskDriveForceReset           Forces a reset of the assocated VDrive
  302.      DiskDriveFormat               Formats a DiskDrive object
  303.      DiskDriveFormatTrack          Formats a track
  304.      DiskDriveGetVolumeSerial      Gets the volume serial
  305.      DiskDriveHasData              Returns TRUE if object valid
  306.      DiskDriveLetter               Returns DiskDrive object letter
  307.      DiskDriveReadSectors          Reads a group of sectors from DiskDrive
  308.      DiskDriveReset                Resets the associated VDrive if used
  309.      DiskDriveSetRead              Sets the associated VDrive for reading
  310.      DiskDriveSetType              Sets the type (density) of VDrive
  311.      DiskDriveSetVolumeSerial      Sets the volume serial
  312.      DiskDriveSetWrite             Sets the associated VDrive for writing
  313.      DiskDriveSetWriteFormatOption Turns on/off WriteFormatOption
  314.      DiskDriveSetWriteVerifyOption Turns on/off WriteVerifyOption
  315.      DiskDriveTruncate             Sets truncation mode on
  316.      DiskDriveTruncateReverse      Sets truncation mode off
  317.      DiskDriveType                 Returns type (density)
  318.      DiskDriveUsedCylinders        Returns cylinders used
  319.      DiskDriveUsedHeads            Returns heads used
  320.      DiskDriveUsedSectorSize       Returns sector size
  321.      DiskDriveUsedSectors          Returns sectors used
  322.      DiskDriveWriteBootSector      Writes boot sector of DiskDrive
  323.      DiskDriveWriteSectors         Writes a group of sectors to DiskDrive
  324. >>DiskDriveCreateDrive
  325. ------------------ SABDU001.DLL API: DiskDriveCreateDrive ------------
  326.  
  327.  UINT FAR PASCAL DiskDriveCreateDrive (
  328.                                        char cDrive
  329.                                        UINT nType,
  330.                                        UINT nCylinders,
  331.                                        lpfnHANDLESTATUS lpfnNewHandleStatus
  332.                                       )
  333.  
  334.       nType = FD0360
  335.               FD0720
  336.               FD1200
  337.               FD1200H
  338.               FD1440
  339.               FD1440H
  340.               FD2880
  341.  
  342.       lpfnNewHandleStatus points to a callback routine that handles event
  343.       notifications including errors.
  344.  
  345.   Creates a DiskDrive object using a physical drive as the base for the
  346.   VDrive object within it.
  347.  
  348.   Returns pointer to DiskDrive object.
  349.  
  350.   Example:
  351.          VOID far *pDiskDriveA ;
  352.  
  353.          FARPROC lpfnNewHandleStatus ;
  354.  
  355.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  356.                                                   NewHandleStatus ) ;
  357.  
  358.          pDiskDriveA = DiskDriveCreateDrive (
  359.                                              'A',
  360.                                              FD1200,
  361.                                              80,
  362.                                              lpfnNewHandleStatus
  363.                                             )
  364. >>DiskDriveCreateMemory
  365. ------------------ SABDU001.DLL API: DiskDriveCreateMemory -----------
  366.  
  367.  UINT FAR PASCAL DiskDriveCreateMemory (
  368.                                         UINT nMemory
  369.                                         UINT nType,
  370.                                         UINT nCylinders,
  371.                                         lpfnHANDLESTATUS lpfnNewHandleStatus
  372.                                        )
  373.  
  374.       nType = FD0360
  375.               FD0720
  376.               FD1200
  377.               FD1200H
  378.               FD1440
  379.               FD1440H
  380.               FD2880
  381.  
  382.       lpfnNewHandleStatus points to a callback routine that handles event
  383.       notifications including errors.
  384.  
  385.   Creates a DiskDrive object using a memory object as the base for the
  386.   VDrive object within it.
  387.  
  388.   Returns pointer to DiskDrive object.
  389.  
  390.   Example:
  391.          VOID far *pDiskDriveA ;
  392.  
  393.          FARPROC lpfnNewHandleStatus ;
  394.  
  395.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  396.                                                   NewHandleStatus ) ;
  397.  
  398.          pDiskDriveA = DiskDriveCreateMemory (
  399.                                               1,
  400.                                               FD1200,
  401.                                               80,
  402.                                               lpfnNewHandleStatus
  403.                                              )
  404. >>DiskDriveCreateFile
  405. ------------------ SABDU001.DLL API: DiskDriveCreateFile -------------
  406.  
  407.  UINT FAR PASCAL DiskDriveCreateFile (
  408.                                       LPCSTR lpczFileName,
  409.                                       LPCSTR lpczApplicationTitle,
  410.                                       LPCSTR lpczVersion,
  411.                                       UINT nType,
  412.                                       UINT nCylinders,
  413.                                       lpfnHANDLESTATUS lpfnNewHandleStatus
  414.                                      )
  415.  
  416.       nType = FD0360
  417.               FD0720
  418.               FD1200
  419.               FD1200H
  420.               FD1440
  421.               FD1440H
  422.               FD2880
  423.  
  424.       lpfnNewHandleStatus points to a callback routine that handles event
  425.       notifications including errors.
  426.  
  427.   Creates a DiskDrive object using a file object as the base for the
  428.   VDrive object within it.
  429.  
  430.   Returns pointer to DiskDrive object.
  431.  
  432.   Example:
  433.          VOID far *pDiskDriveA ;
  434.  
  435.          FARPROC lpfnNewHandleStatus ;
  436.  
  437.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  438.                                                   NewHandleStatus ) ;
  439.  
  440.          pDiskDriveA = DiskDriveCreateFile (
  441.                                             "FileName.SD",
  442.                                             "SAB Diskette Utility",
  443.                                             "2.00",
  444.                                             FD1200,
  445.                                             80,
  446.                                             lpfnNewHandleStatus
  447.                                            )
  448. >>DiskDriveCreateVDrive
  449. ------------------ SABDU001.DLL API: DiskDriveCreateVDrive -----------
  450.  
  451.  UINT FAR PASCAL DiskDriveCreateVDrive (
  452.                                         VOID far * pVDrive,
  453.                                         UINT nType,
  454.                                         UINT nCylinders,
  455.                                         lpfnHANDLESTATUS lpfnNewHandleStatus
  456.                                        )
  457.  
  458.       nType = FD0360
  459.               FD0720
  460.               FD1200
  461.               FD1200H
  462.               FD1440
  463.               FD1440H
  464.               FD2880
  465.  
  466.       lpfnNewHandleStatus points to a callback routine that handles event
  467.       notifications including errors.
  468.  
  469.   Creates a DiskDrive object using a virtual drive object as the
  470.   base for the VDrive object within it.
  471.  
  472.   Returns pointer to DiskDrive object.
  473.  
  474.   Example:
  475.          VOID far *pDiskDriveA ;
  476.          VOID far *pVDriveA ;
  477.  
  478.          FARPROC lpfnNewHandleStatus ;
  479.  
  480.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  481.                                                   NewHandleStatus ) ;
  482.          pVDriveA = VDrive ( 'A' ) ;
  483.  
  484.          pDiskDriveA = DiskDriveCreateFile (
  485.                                             pVDriveA,
  486.                                             FD1200,
  487.                                             80,
  488.                                             lpfnNewHandleStatus
  489.                                            )
  490. >>DiskDriveDelete
  491. ------------------ SABDU001.DLL API: DiskDriveDelete -----------------
  492.  
  493.  UINT FAR PASCAL DiskDriveDelete (
  494.                                   VOID far * pVDrive,
  495.                                  )
  496.  
  497.   Deletes a DiskDrive object.
  498.  
  499.   Example:
  500.          VOID far *pDiskDriveA ;
  501.          VOID far *pVDriveA ;
  502.  
  503.          FARPROC lpfnNewHandleStatus ;
  504.  
  505.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  506.                                                   NewHandleStatus ) ;
  507.          pVDriveA = VDrive ( 'A' ) ;
  508.  
  509.          pDiskDriveA = DiskDriveCreateFile (
  510.                                             pVDriveA,
  511.                                             FD1200,
  512.                                             80,
  513.                                             lpfnNewHandleStatus
  514.                                            )
  515.          ...
  516.          DiskDriveDelete ( pDiskDriveA ) ;
  517.          pDiskDriveA = NULL ;
  518.  
  519. >>DiskDriveCopy
  520. ------------------ SABDU001.DLL API: DiskDriveCopy -------------------
  521.  
  522.  UINT FAR PASCAL DiskDriveCopy (
  523.                                 VOID far * pDiskDriveTarget,
  524.                                 VOID far * pDiskDriveSource
  525.                                )
  526.  
  527.   Copies a DiskDrive object ;
  528.  
  529.   Example:
  530.          VOID far *pDiskDriveA ;
  531.          VOID far *pDiskDriveB ;
  532.  
  533.          FARPROC lpfnNewHandleStatus ;
  534.  
  535.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  536.                                                   NewHandleStatus ) ;
  537.          pVDriveA = VDrive ( 'A' ) ;
  538.  
  539.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  540.                                               lpfnNewHandleStatus ) ;
  541.          pDiskDriveB = DiskDriveCreateDrive ( 'B',
  542.                                               DiskDriveType( pDiskDriveA ),
  543.                                               0, lpfnNewHandleStatus ) ;
  544.          DiskDriveCopy ( pDiskDriveB, pDiskDriveA ) ;
  545. >>DiskDriveCompare
  546. ------------------ SABDU001.DLL API: DiskDriveCompare ----------------
  547.  
  548.  UINT FAR PASCAL DiskDriveCompare (
  549.                                    VOID far * pDiskDriveTarget,
  550.                                    VOID far * pDiskDriveSource
  551.                                   )
  552.  
  553.   Compares two DiskDrive objects.
  554.  
  555.   Returns TRUE if they are the same.
  556.  
  557.   Example:
  558.          VOID far *pDiskDriveA ;
  559.          VOID far *pDiskDriveB ;
  560.  
  561.          FARPROC lpfnNewHandleStatus ;
  562.  
  563.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  564.                                                   NewHandleStatus ) ;
  565.          pVDriveA = VDrive ( 'A' ) ;
  566.  
  567.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  568.                                               lpfnNewHandleStatus ) ;
  569.          pDiskDriveB = DiskDriveCreateDrive ( 'B',
  570.                                               DiskDriveType( pDiskDriveA ),
  571.                                               0, lpfnNewHandleStatus ) ;
  572.          DiskDriveCompare ( pDiskDriveB, pDiskDriveA ) ;
  573. >>DiskDriveFormatTrack
  574. ------------------ SABDU001.DLL API: DiskDriveFormatTrack ------------
  575.  
  576.  UINT FAR PASCAL DiskDriveFormatTrack (
  577.                                        VOID far * pDiskDrive,
  578.                                        UINT nCylinder,
  579.                                        UINT nHead,
  580.                                        lpfnHANDLESTATUS lpfnHandleStatus
  581.                                       )
  582.  
  583.   Formats a track.
  584.  
  585.   Returns FALSE if successfull
  586.  
  587.   Example:
  588.          VOID far *pDiskDriveA ;
  589.  
  590.          FARPROC lpfnNewHandleStatus ;
  591.  
  592.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  593.                                                   NewHandleStatus ) ;
  594.          pVDriveA = VDrive ( 'A' ) ;
  595.  
  596.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1200, 80,
  597.                                               lpfnNewHandleStatus ) ;
  598.          DiskDriveFormatTrack ( pDiskDriveB, 0, 1,
  599.                                 lpfnNewHandleStatus ) ;
  600. >>DiskDriveReadSectors
  601. ------------------ SABDU001.DLL API: DiskDriveReadSectors ------------
  602.  
  603.  UINT FAR PASCAL DiskDriveReadSectors (
  604.                                        VOID far * pDiskDrive,
  605.                                        UINT nCylinder,
  606.                                        UINT nHead,
  607.                                        UINT nSector,
  608.                                        UINT nCount,
  609.                                        LPBYTE lpbyBuffer,
  610.                                        lpfnHANDLESTATUS lpfnHandleStatus
  611.                                       )
  612.  
  613.   Reads a group of sectors.
  614.  
  615.   Returns FALSE if successfull
  616.  
  617.   Example:
  618.          VOID far *pDiskDriveA ;
  619.  
  620.          FARPROC lpfnNewHandleStatus ;
  621.  
  622.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  623.                                                   NewHandleStatus ) ;
  624.          pVDriveA = VDrive ( 'A' ) ;
  625.  
  626.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  627.                                               lpfnNewHandleStatus ) ;
  628.          DiskDriveReadSectors ( pDiskDriveA, 0, 1, 0, 18,
  629.                                 lpfnNewHandleStatus ) ;
  630. >>DiskDriveWriteSectors
  631. ------------------ SABDU001.DLL API: DiskDriveWriteSectors -----------
  632.  
  633.  UINT FAR PASCAL DiskDriveWriteSectors (
  634.                                         VOID far * pDiskDrive,
  635.                                         UINT nCylinder,
  636.                                         UINT nHead,
  637.                                         UINT nSector,
  638.                                         UINT nCount,
  639.                                         LPBYTE lpbyBuffer,
  640.                                         lpfnHANDLESTATUS lpfnHandleStatus
  641.                                        )
  642.  
  643.   Writes a group of sectors.
  644.  
  645.   Returns FALSE if successfull
  646.  
  647.   Example:
  648.          VOID far *pDiskDriveA ;
  649.  
  650.          FARPROC lpfnNewHandleStatus ;
  651.  
  652.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  653.                                                   NewHandleStatus ) ;
  654.          pVDriveA = VDrive ( 'A' ) ;
  655.  
  656.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  657.                                               lpfnNewHandleStatus ) ;
  658.          DiskDriveWriteSectors ( pDiskDriveA, 0, 1, 0, 18,
  659.                                  lpfnNewHandleStatus ) ;
  660. >>DiskDriveLetter
  661. ------------------ SABDU001.DLL API: DiskDriveWriteLetter ------------
  662.  
  663.  UINT FAR PASCAL DiskDriveLetter (
  664.                                   VOID far * pDiskDrive,
  665.                                  )
  666.  
  667.   Returns letter of virtual drive.
  668.  
  669.   Example:
  670.          VOID far *pDiskDriveA ;
  671.  
  672.          char cDriveLetter ;
  673.  
  674.          FARPROC lpfnNewHandleStatus ;
  675.  
  676.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  677.                                                   NewHandleStatus ) ;
  678.          pVDriveA = VDrive ( 'A' ) ;
  679.  
  680.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  681.                                               lpfnNewHandleStatus ) ;
  682.          ...
  683.          cDriveLetter = DiskDriveLetter ( pDiskDriveA ) ;
  684. >>DiskDriveSetRead
  685. ------------------ SABDU001.DLL API: DiskDriveSetRead ---------------
  686.  
  687.  UINT FAR PASCAL DiskDriveSetRead (
  688.                                    VOID far * pDiskDrive,
  689.                                   )
  690.  
  691.   Sets contained virtual drive for reading.
  692.  
  693.   Example:
  694.          VOID far *pDiskDriveA ;
  695.  
  696.          char cDriveLetter ;
  697.  
  698.          FARPROC lpfnNewHandleStatus ;
  699.  
  700.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  701.                                                   NewHandleStatus ) ;
  702.          pVDriveA = VDrive ( 'A' ) ;
  703.  
  704.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  705.                                               lpfnNewHandleStatus ) ;
  706.          ...
  707.          DiskDriveSetRead ( pDiskDriveA ) ;
  708. >>DiskDriveSetWrite
  709. ------------------ SABDU001.DLL API: DiskDriveSetWrite---------------
  710.  
  711.  UINT FAR PASCAL DiskDriveSetWrite (
  712.                                     VOID far * pDiskDrive,
  713.                                    )
  714.  
  715.   Sets contained virtual drive for writing.
  716.  
  717.   Example:
  718.          VOID far *pDiskDriveA ;
  719.  
  720.          char cDriveLetter ;
  721.  
  722.          FARPROC lpfnNewHandleStatus  ;
  723.  
  724.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  725.                                                   NewHandleStatus ) ;
  726.          pVDriveA = VDrive ( 'A' ) ;
  727.  
  728.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  729.                                               lpfnNewHandleStatus ) ;
  730.          ...
  731.          DiskDriveSetWrite ( pDiskDriveA ) ;
  732. >>DiskDriveSetWriteFormatOption
  733. ------------------ SABDU001.DLL API: DiskDriveSetWriteFormatOption --
  734.  
  735.  UINT FAR PASCAL DiskDriveSetWriteFormatOption (
  736.                                                 VOID far * pDiskDrive,
  737.                                                 UINT nWriteFormatOptionNew
  738.                                                )
  739.  
  740.   nWriteFormatOptionNew
  741.       1                 AUTOMATIC
  742.       2                 ALWAYS
  743.       3                 NEVER
  744.       4                 FAST
  745.  
  746.   Sets write format option.
  747.  
  748.   Example:
  749.          VOID far *pDiskDriveA ;
  750.  
  751.          char cDriveLetter ;
  752.  
  753.          FARPROC lpfnNewHandleStatus ;
  754.  
  755.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  756.                                                   NewHandleStatus ) ;
  757.          pVDriveA = VDrive ( 'A' ) ;
  758.  
  759.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  760.                                               lpfnNewHandleStatus ) ;
  761.          ...
  762.          DiskDriveSetWriteFormatOption ( pDiskDriveA, AUTOMATIC ) ;
  763. >>DiskDriveSetWriteVerifyOption
  764. ------------------ SABDU001.DLL API: DiskDriveSetWriteVerifyOption --
  765.  
  766.  UINT FAR PASCAL DiskDriveSetWriteVerifyOption (
  767.                                                 VOID far * pDiskDrive,
  768.                                                 BOOL bWriteVerifyOptionNew
  769.                                                )
  770.  
  771.   Sets write verify option.
  772.  
  773.   Example:
  774.          VOID far *pDiskDriveA ;
  775.  
  776.          char cDriveLetter ;
  777.  
  778.          FARPROC lpfnNewHandleStatus ;
  779.  
  780.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  781.                                                   NewHandleStatus ) ;
  782.          pVDriveA = VDrive ( 'A' ) ;
  783.  
  784.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  785.                                               lpfnNewHandleStatus ) ;
  786.          ...
  787.          DiskDriveSetWriteVerifyOption ( pDiskDriveA, TRUE ) ;
  788. >>DiskDriveReset
  789. ------------------ SABDU001.DLL API: DiskDriveReset ------------------
  790.  
  791.  UINT FAR PASCAL DiskDriveReset (
  792.                                  VOID far * pDiskDrive
  793.                                 )
  794.  
  795.   Resets virtual drive
  796.  
  797.   Example:
  798.          VOID far *pDiskDriveA ;
  799.  
  800.          char cDriveLetter ;
  801.  
  802.          FARPROC lpfnNewHandleStatus ;
  803.  
  804.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  805.                                                   NewHandleStatus ) ;
  806.          pVDriveA = VDrive ( 'A' ) ;
  807.  
  808.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  809.                                               lpfnNewHandleStatus ) ;
  810.          ...
  811.          DiskDriveReset ( pDiskDriveA ) ;
  812. >>DiskDriveForceReset
  813. ------------------ SABDU001.DLL API: DiskDriveForceReset -------------
  814.  
  815.  UINT FAR PASCAL DiskDriveForceReset (
  816.                                       VOID far * pDiskDrive
  817.                                      )
  818.  
  819.   Forces reset of virtual drive
  820.  
  821.   Example:
  822.          VOID far *pDiskDriveA ;
  823.  
  824.          char cDriveLetter ;
  825.  
  826.          FARPROC lpfnNewHandleStatus ;
  827.  
  828.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  829.                                                   NewHandleStatus ) ;
  830.          pVDriveA = VDrive ( 'A' ) ;
  831.  
  832.          pDiskDriveA = DiskDriveCreateDrive ( 'A', FD1440, 0,
  833.                                               lpfnNewHandleStatus ) ;
  834.          ...
  835.          DiskDriveForceReset ( pDiskDriveA ) ;
  836. >>DiskDriveType
  837. ------------------ SABDU001.DLL API: DiskDriveType -------------------
  838.  
  839.  UINT FAR PASCAL DiskDriveType (
  840.                                 VOID far * pDiskDrive
  841.                                )
  842.  
  843.   Returns type ( density ).
  844.  
  845.   Example:
  846.          VOID far *pDiskDriveA ;
  847.  
  848.          char cDriveLetter ;
  849.  
  850.          FARPROC lpfnNewHandleStatus ;
  851.  
  852.          UINT nType ;
  853.  
  854.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  855.                                                   NewHandleStatus ) ;
  856.          pVDriveA = VDrive ( 'A' ) ;
  857.  
  858.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  859.                                               lpfnNewHandleStatus ) ;
  860.          ...
  861.          nType = DiskDriveType ( pDiskDriveA ) ;
  862. >>DiskDriveHasData
  863. ------------------ SABDU001.DLL API: DiskDriveHasData ----------------
  864.  
  865.  UINT FAR PASCAL DiskDriveHasData (
  866.                                    VOID far * pDiskDrive
  867.                                   )
  868.  
  869.   Returns TRUE if DiskDrive is valid object.
  870.  
  871.   Example:
  872.          VOID far *pDiskDriveA ;
  873.  
  874.          FARPROC lpfnNewHandleStatus ;
  875.  
  876.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  877.                                                   NewHandleStatus ) ;
  878.          pVDriveA = VDrive ( 'A' ) ;
  879.  
  880.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  881.                                               lpfnNewHandleStatus ) ;
  882.          ...
  883.          if ( DiskDriveHasData ( pDiskDriveA ) ) ...;
  884. >>DiskDriveFormat
  885. ------------------ SABDU001.DLL API: DiskDriveFormat -----------------
  886.  
  887.  UINT FAR PASCAL DiskDriveFormat (
  888.                                   VOID far * pDiskDrive,
  889.                                   LPCSTR lpczVolumeSerial,
  890.                                   UNIT nFormatOption,
  891.                                   LPBYTE lpbyBootSector,
  892.                                   lpfnHANDLESTATUS lpfnHandleStatus
  893.                                  )
  894.  
  895.   Returns FALSE if successfull.
  896.  
  897.   Example:
  898.          VOID far *pDiskDriveA ;
  899.  
  900.          char cDriveLetter ;
  901.  
  902.          FARPROC lpfnNewHandleStatus ;
  903.  
  904.          UINT nType ;
  905.  
  906.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  907.                                                   NewHandleStatus ) ;
  908.          pVDriveA = VDrive ( 'A' ) ;
  909.  
  910.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  911.                                               lpfnNewHandleStatus ) ;
  912.          ...
  913.          DiskDriveFormat ( pDiskDriveA, "VOL 1", FORMATFAST, NULL, NULL ) ;
  914. >>DiskDriveSetType
  915. ------------------ SABDU001.DLL API: DiskDriveSetType ----------------
  916.  
  917.  UINT FAR PASCAL DiskDriveSetType (
  918.                                    VOID far * pDiskDrive,
  919.                                    UINT nNewType
  920.                                   )
  921.  
  922.   Example:
  923.          VOID far *pDiskDriveA ;
  924.  
  925.          char cDriveLetter ;
  926.  
  927.          FARPROC lpfnNewHandleStatus ;
  928.  
  929.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  930.                                                   NewHandleStatus ) ;
  931.          pVDriveA = VDrive ( 'A' ) ;
  932.  
  933.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  934.                                               lpfnNewHandleStatus ) ;
  935.          ...
  936.          DiskDriveSetType ( pDiskDriveA, FD1200 ) ;
  937. >>DiskDriveUsedCylinders
  938. ------------------ SABDU001.DLL API: DiskDriveUsedCylinders ----------
  939.  
  940.  UINT FAR PASCAL DiskDriveUsedCylinders (
  941.                                          VOID far * pDiskDrive
  942.                                          )
  943.  
  944.   Returns number of cylinders.
  945.  
  946.   Example:
  947.          VOID far *pDiskDriveA ;
  948.  
  949.          char cDriveLetter ;
  950.  
  951.          FARPROC lpfnNewHandleStatus ;
  952.  
  953.          UINT nCylinder ;
  954.  
  955.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  956.                                                   NewHandleStatus ) ;
  957.          pVDriveA = VDrive ( 'A' ) ;
  958.  
  959.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  960.                                               lpfnNewHandleStatus ) ;
  961.          ...
  962.          nCylinder = DiskDriveUsedCylinders ( pDiskDriveA ) ;
  963. >>DiskDriveUsedHeads
  964. ------------------ SABDU001.DLL API: DiskDriveHeads ------------------
  965.  
  966.  UINT FAR PASCAL DiskDriveUsedHeads (
  967.                                      VOID far * pDiskDrive
  968.                                     )
  969.  
  970.   Returns number of heads.
  971.  
  972.   Example:
  973.          VOID far *pDiskDriveA ;
  974.  
  975.          char cDriveLetter ;
  976.  
  977.          FARPROC lpfnNewHandleStatus ;
  978.  
  979.          UINT nHeads ;
  980.  
  981.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  982.                                                   NewHandleStatus ) ;
  983.          pVDriveA = VDrive ( 'A' ) ;
  984.  
  985.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  986.                                               lpfnNewHandleStatus ) ;
  987.          ...
  988.          nHeads = DiskDriveUsedHeads ( pDiskDriveA ) ;
  989. >>DiskDriveUsedSectors
  990. ------------------ SABDU001.DLL API: DiskDriveUsedSectors ------------
  991.  
  992.  UINT FAR PASCAL DiskDriveUsedSectors (
  993.                                        VOID far * pDiskDrive
  994.                                       )
  995.  
  996.   Returns number of sectors in a track.
  997.  
  998.   Example:
  999.          VOID far *pDiskDriveA ;
  1000.  
  1001.          char cDriveLetter ;
  1002.  
  1003.          FARPROC lpfnNewHandleStatus ;
  1004.  
  1005.          UINT nSectors ;
  1006.  
  1007.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  1008.                                                   NewHandleStatus ) ;
  1009.          pVDriveA = VDrive ( 'A' ) ;
  1010.  
  1011.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  1012.                                               lpfnNewHandleStatus ) ;
  1013.          ...
  1014.          nSectors = DiskDriveUsedSectors ( pDiskDriveA ) ;
  1015. >>DiskDriveUsedSectorSize
  1016. ------------------ SABDU001.DLL API: DiskDriveUsedSectorSize----------
  1017.  
  1018.  UINT FAR PASCAL DiskDriveUsedSectorSize (
  1019.                                           VOID far * pDiskDrive
  1020.                                          )
  1021.  
  1022.   Returns sector size.
  1023.  
  1024.   Example:
  1025.          VOID far *pDiskDriveA ;
  1026.  
  1027.          LPSTR *lpczOldVolumeSerial ;
  1028.  
  1029.          FARPROC lpfnNewHandleStatus ;
  1030.  
  1031.          UINT nSectorSize ;
  1032.  
  1033.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  1034.                                                   NewHandleStatus ) ;
  1035.          pVDriveA = VDrive ( 'A' ) ;
  1036.  
  1037.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  1038.                                               lpfnNewHandleStatus ) ;
  1039.          ...
  1040.          nSectorSize = DiskDriveUsedSectorSize ( pDiskDriveA ) ;
  1041. >>DiskDriveGetVolumeSerial
  1042. ------------------ SABDU001.DLL API: DiskDriveGetVolumeSerial --------
  1043.  
  1044.  UINT FAR PASCAL DiskDriveGetVolumeSerial (
  1045.                                            VOID far * pDiskDrive,
  1046.                                            LPSTR lpczOldVolumeSerial
  1047.                                           )
  1048.  
  1049.   Example:
  1050.          VOID far *pDiskDriveA ;
  1051.  
  1052.          char cDriveLetter ;
  1053.  
  1054.          FARPROC lpfnNewHandleStatus ;
  1055.  
  1056.          UINT nType ;
  1057.  
  1058.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  1059.                                                   NewHandleStatus ) ;
  1060.          pVDriveA = VDrive ( 'A' ) ;
  1061.  
  1062.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  1063.                                               lpfnNewHandleStatus ) ;
  1064.          ...
  1065.          DiskDriveGetVolumeSerial ( pDiskDriveA, lpczOldVolumeSerial ) ;
  1066. >>DiskDriveSetVolumeSerial
  1067. ------------------ SABDU001.DLL API: DiskDriveSetVolumeSerial --------
  1068.  
  1069.  UINT FAR PASCAL DiskDriveSetVolumeSerial (
  1070.                                            VOID far * pDiskDrive,
  1071.                                            LPSTR lpczNewVolumeSerial
  1072.                                           )
  1073.  
  1074.   Returns FALSE if successfull.
  1075.  
  1076.   Example:
  1077.          VOID far *pDiskDriveA ;
  1078.  
  1079.          FARPROC lpfnNewHandleStatus ;
  1080.  
  1081.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  1082.                                                   NewHandleStatus ) ;
  1083.          pVDriveA = VDrive ( 'A' ) ;
  1084.  
  1085.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  1086.                                               lpfnNewHandleStatus ) ;
  1087.          ...
  1088.          DiskDriveSetVolumeSerial ( pDiskDriveA, "Vol 1" ) ;
  1089. >>DiskDriveTruncate
  1090. ------------------ SABDU001.DLL API: DiskDriveTruncate ---------------
  1091.  
  1092.  UINT FAR PASCAL DiskDriveTruncate (
  1093.                                     VOID far * pDiskDrive
  1094.                                    )
  1095.  
  1096.   Turns on truncation.
  1097.  
  1098.   Example:
  1099.          VOID far *pDiskDriveA ;
  1100.  
  1101.          FARPROC lpfnNewHandleStatus ;
  1102.  
  1103.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  1104.                                                   NewHandleStatus ) ;
  1105.          pVDriveA = VDrive ( 'A' ) ;
  1106.  
  1107.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  1108.                                               lpfnNewHandleStatus ) ;
  1109.          ...
  1110.          DiskDriveTypeTruncate ( pDiskDriveA ) ;
  1111. >>DiskDriveTruncateRevers
  1112. ------------------ SABDU001.DLL API: DiskDriveTruncateReverse --------
  1113.  
  1114.  UINT FAR PASCAL DiskDriveTruncateReverse (
  1115.                                            VOID far * pDiskDrive
  1116.                                           )
  1117.  
  1118.   Turns off truncation.
  1119.  
  1120.   Example:
  1121.          VOID far *pDiskDriveA ;
  1122.  
  1123.          FARPROC lpfnNewHandleStatus ;
  1124.  
  1125.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  1126.                                                   NewHandleStatus ) ;
  1127.          pVDriveA = VDrive ( 'A' ) ;
  1128.  
  1129.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  1130.                                               lpfnNewHandleStatus ) ;
  1131.          ...
  1132.          DiskDriveTruncateReverse ( pDiskDriveA ) ;
  1133. >>DiskDriveWriteBootSector
  1134. ------------------ SABDU001.DLL API: DiskDriveWriteBootSector --------
  1135.  
  1136.  UINT FAR PASCAL DiskDriveWriteBootSector (
  1137.                                            VOID far * pDiskDrive,
  1138.                                            lpbyModelBootSector,
  1139.                                lpfnHANDLESTATUS lpfnNewHandleStatus
  1140.                               )
  1141.  
  1142.   Returns false if successfull.
  1143.  
  1144.   Example:
  1145.          VOID far *pDiskDriveA ;
  1146.  
  1147.          FARPROC lpfnNewHandleStatus ;
  1148.  
  1149.          lpfnNewHandleStatus = MakeProcInstance ( hInstance,
  1150.                                                   NewHandleStatus ) ;
  1151.          pVDriveA = VDrive ( 'A' ) ;
  1152.  
  1153.          pDiskDriveA = DiskDriveCreateDrive ( 'A', 0, 0,
  1154.                                               lpfnNewHandleStatus ) ;
  1155.          ...
  1156.          DiskDriveTypeWriteBootSector ( pDiskDriveA, NULL, NULL ) ;
  1157. >>FDrive
  1158. ------------------ SABDU001.DLL API: FDrive objects ------------------
  1159.  
  1160.  A FDrive (File Drive) is a specialized version of the VDrive
  1161.  (Virtual Drive).  It is an object that represents a diskette image
  1162.  file.
  1163.  
  1164.  The following functions are available to manipulate it:
  1165.      FDriveCreate        Creates a FDrive object
  1166.      FDriveDelete        Deletes a FDrive object
  1167.      FDriveForceReset    Issues a reset to the drive
  1168.      FDriveFormatTrack   Formats a track
  1169.      FDriveReadSectors   Reads a group of sectors from the drive
  1170.      FDriveReset         Issues a reset to the drive if it was used
  1171.      FDriveSetRead       Sets up for reading from the drive
  1172.      FDriveSetWrite      Sets up for writing to the drive
  1173.      FDriveWriteSectors  Writes a group of sectors to the drive
  1174. >>FDriveCreate
  1175. ------------------ SABDU001.DLL API: FDriveCreate --------------------
  1176.  
  1177.  VOID far * FAR PASCAL FDriveCreate (
  1178.                                      LPCSTR lpczFileName,
  1179.                                      LPCSTR lpczApplicationTitle,
  1180.                                      LPCSTR lpczVersion
  1181.                                     )
  1182.  
  1183.  Creates a FDrive object associated with drive cDrive and returns a
  1184.  pointer to it.
  1185.  
  1186.  Example:
  1187.          VOID far *pDriveA ;
  1188.  
  1189.          pDriveA = FDriveCreate ( 'A' ) ;
  1190. >>FDriveDelete
  1191. ------------------ SABDU001.DLL API: FDriveDelete --------------------
  1192.  
  1193.  VOID       FAR PASCAL FDriveDelete (
  1194.                                      pFDrive
  1195.                                     )
  1196.  
  1197.  Deletes the FDrive object pointed to by pFDrive.
  1198.  
  1199.  Example:
  1200.          VOID far *pDriveA ;
  1201.  
  1202.          pDriveA = FDriveCreate ( 'A' ) ;
  1203.          ...
  1204.          FDriveDelete ( pDriveA ) ;
  1205.          pDriveA = NULL ;
  1206. >>FDriveSetRead
  1207. ------------------ SABDU001.DLL API: FDriveSetRead -------------------
  1208.  
  1209.  UINT       FAR PASCAL FDriveSetRead (
  1210.                                       VOID far *pFDrive,
  1211.                                       UINT nTempType,
  1212.                                       UINT nCylinders
  1213.                                      )
  1214.  
  1215.  Prepares the FDrive object pointed to by pFDrive for reading.
  1216.  
  1217.  nTempType defines the type of diskette expected:
  1218.            FD0360 FD0720 FD1200 FD1440 FD2880
  1219.  
  1220.  nCylinders defines the number of cylinders.
  1221.  
  1222.  Example:
  1223.          VOID far *pDriveA ;
  1224.  
  1225.          pDriveA = FDriveCreate ( 'A' ) ;
  1226.          ...
  1227.          FDriveSetRead ( pDriveA, FD0360, NULL ) ;
  1228. >>FDriveSetWrite
  1229. ------------------ SABDU001.DLL API: FDriveSetWrite ------------------
  1230.  
  1231.  UINT       FAR PASCAL FDriveSetWrite (
  1232.                                        VOID far *pFDrive,
  1233.                                        UINT nTempType,
  1234.                                        UINT nCylinders
  1235.                                       )
  1236.  
  1237.  Prepares the FDrive object pointed to by pFDrive for writing.
  1238.  
  1239.  nTempType defines the type of diskette expected:
  1240.            FD0360 FD0720 FD1200 FD1440 FD2880
  1241.  
  1242.  nCylinders defines the number of cylinders.
  1243.  
  1244.  Example:
  1245.          VOID far *pDriveA ;
  1246.  
  1247.          pDriveA = FDriveCreate ( 'A' ) ;
  1248.          ...
  1249.          FDriveSetWrite ( pDriveA, FD0360, NULL ) ;
  1250. >>FDriveReset
  1251. ------------------ SABDU001.DLL API: FDriveReset ---------------------
  1252.  
  1253.  UINT       FAR PASCAL FDriveReset (
  1254.                                     VOID far *pFDrive
  1255.                                    )
  1256.  
  1257.  Resets the FDrive object pointed to by pFDrive.
  1258.  
  1259.  Example:
  1260.          VOID far *pDriveA ;
  1261.  
  1262.          pDriveA = FDriveCreate ( 'A' ) ;
  1263.          ...
  1264.          FDriveReset ( pDriveA ) ;
  1265. >>FDriveForceReset
  1266. ------------------ SABDU001.DLL API: FDriveForceReset ----------------
  1267.  
  1268.  UINT       FAR PASCAL FDriveForceReset (
  1269.                                          VOID far *pFDrive
  1270.                                         )
  1271.  
  1272.  Resets the FDrive object pointed to by pFDrive.
  1273.  
  1274.  Example:
  1275.          VOID far *pDriveA ;
  1276.  
  1277.          pDriveA = FDriveCreate ( 'A' ) ;
  1278.          ...
  1279.          FDriveForceReset ( pDriveA ) ;
  1280. >>FDriveFormatTrack
  1281. ------------------ SABDU001.DLL API: FDriveFormatTrack ---------------
  1282.  
  1283.  UINT       FAR PASCAL FDriveForceReset (
  1284.                                          VOID far *pFDrive,
  1285.                                          UNIT nCylinder,
  1286.                                          UNIT nHead
  1287.                                         )
  1288.  
  1289.  Formats the track pointed to by FDrive object pointer
  1290.  
  1291.  Example:
  1292.          VOID far *pDriveA ;
  1293.  
  1294.          pDriveA = FDriveCreate ( pDriveA ) ;
  1295.          ...
  1296.          FDriveFormatTrack ( pDriveA, nCylinder, nHead ) ;
  1297. >>FDriveReadSectors
  1298. ------------------ SABDU001.DLL API: FDriveReadSectors ---------------
  1299.  
  1300.  UINT       FAR PASCAL FDriveReadSectors (
  1301.                                           VOID far *pFDrive,
  1302.                                           UNIT nCylinder,
  1303.                                           UNIT nHead,
  1304.                                           UINT nSector,
  1305.                                           UINT nCount,
  1306.                                           LPBYTE lpcBuffer
  1307.                                          )
  1308.  
  1309.  Reads a group of sectors from the drive pointerd to by pFDrive
  1310.  
  1311.  nCylinder     Cylinder to read from
  1312.  nHead         Head to read with
  1313.  nSector       Starting sector
  1314.  nCount        Number of sectors to read
  1315.  lpcBuffer     Buffer to contain the data read.
  1316.  
  1317.  Example:
  1318.          VOID far *pDriveA ;
  1319.  
  1320.          pDriveA = FDriveCreate ( pDriveA ) ;
  1321.          ...
  1322.          FDriveReadSectors ( pDriveA, nCylinder, nHead, nSector,
  1323.                              nCount, lpcBuffer ) ;
  1324. >>FDriveWriteSectors
  1325. ------------------ SABDU001.DLL API: FDriveWriteSectors --------------
  1326.  
  1327.  UINT       FAR PASCAL FDriveWriteSectors (
  1328.                                            VOID far *pFDrive,
  1329.                                            UNIT nCylinder,
  1330.                                            UNIT nHead,
  1331.                                            UINT nSector,
  1332.                                            UINT nCount,
  1333.                                            LPBYTE lpcBuffer
  1334.                                           )
  1335.  
  1336.  Writes a group of sectors from the drive pointerd to by pFDrive
  1337.  
  1338.  nCylinder     Cylinder to read from
  1339.  nHead         Head to read with
  1340.  nSector       Starting sector
  1341.  nCount        Number of sectors to read
  1342.  lpcBuffer     Buffer to contain the data read.
  1343.  
  1344.  Example:
  1345.          VOID far *pDriveA ;
  1346.  
  1347.          pDriveA = FDriveCreate ( pDriveA ) ;
  1348.          ...
  1349.          FDriveWriteSectors ( pDriveA, nCylinder, nHead, nSector,
  1350.                               nCount, lpcBuffer ) ;
  1351. >>HandleStatus
  1352. ------------------ SABDU001.DLL Callback: HandleStatus ---------------
  1353.  
  1354. typedef int (FAR PASCAL __export * lpfnHANDLESTATUS)(
  1355.                                                      UINT nStatus1,
  1356.                                                      UINT nStatus2,
  1357.                                                      UINT nParam1,
  1358.                                                      UINT nParam2,
  1359.                                                      LONG lParam1,
  1360.                                                      LONG lParam2
  1361.                                                     ) ;
  1362.  
  1363. int  FAR PASCAL __export HandleStatus (
  1364.                                        UINT nStatus1,
  1365.                                        UINT nStatus2,
  1366.                                        UINT nParam1,
  1367.                                        UINT nParam2,
  1368.                                        LONG lParam1,
  1369.                                        LONG lParam2
  1370.                                       ) ;
  1371.  
  1372.   nStatus1
  1373.   -------------------
  1374.     nStatus2                    nParam1               nParam2
  1375.     --------------------------- --------------------- --------------------
  1376.                                   lParam1               lParam2
  1377.                                   --------------------- ---------------
  1378.  
  1379.   STATUS1_INIT                  hWnd                  hInstance
  1380.   STATUS1_START
  1381.   STATUS1_BOOT_SECTOR
  1382.   STATUS1_DIRECTORY
  1383.   STATUS1_FAT
  1384.   STATUS1_SYSTEM_FILE
  1385.   STATUS1_CYLINDER              cylinder              percent complete
  1386.   STATUS1_HEAD
  1387.   STATUS1_END
  1388.   STATUS1_ERROR
  1389.     STATUS2_FILE                STATUS3_OPEN_FAIL
  1390.                                   file name pointer
  1391.     STATUS2_FILE                STATUS3_OPEN_FILE_IO_ERROR
  1392.                                   file name pointer
  1393.     STATUS2_FILE                STATUS3_OPEN_INPUT_BAD
  1394.                                   file name pointer
  1395.     STATUS2_FILE                STATUS3_OPEN_FLAGS_BAD
  1396.                                   file name pointer
  1397.     STATUS2_FILE                STATUS3_OPEN_NOT_SUPPORTED
  1398.                                   file name pointer
  1399.     STATUS2_READ                cylinder              head
  1400.     STATUS2_WRITE               cylinder              head
  1401.     STATUS2_FORMAT              cylinder              head
  1402.     STATUS2_FILE_READ
  1403.                                   file name pointer
  1404.     STATUS2_FILE_WRITE
  1405.                                   file name pointer
  1406.     STATUS2_DISK_SPACE
  1407.                                   space needed          space available
  1408.     STATUS2_HEAD                cylinder              head
  1409.     STATUS2_MEMORY
  1410.     STATUS2_SYSTEM
  1411.     STATUS2_FAT
  1412.     STATUS2_DIRECTORY
  1413.     STATUS2_BOOT_SECTOR
  1414.     STATUS2_SYSTEM_FILE_MISSING
  1415.     STATUS2_SYSTEM_FILE_OPEN
  1416.     STATUS2_COMPARE             cylinder              head
  1417.     STATUS2_DPT
  1418. >>MDrive
  1419. ------------------ SABDU001.DLL API: MDrive objects ------------------
  1420.  
  1421.  A MDrive (Memory Drive) is a specialized version of the VDrive
  1422.  (Virtual Drive).  It is an object that represents a diskette image in
  1423.  memory.
  1424.  
  1425.  The following functions are available to manipulate it:
  1426.      MDriveCreate        Creates a MDrive object
  1427.      MDriveDelete        Deletes a MDrive object
  1428.      MDriveForceReset    Issues a reset to the drive
  1429.      MDriveFormatTrack   Formats a track
  1430.      MDriveReadSectors   Reads a group of sectors from the drive
  1431.      MDriveReset         Issues a reset to the drive if it was used
  1432.      MDriveSetRead       Sets up for reading from the drive
  1433.      MDriveSetWrite      Sets up for writing to the drive
  1434.      MDriveWriteSectors  Writes a group of sectors to the drive
  1435. >>MDriveCreate
  1436. ------------------ SABDU001.DLL API: MDriveCreate --------------------
  1437.  
  1438.  VOID far * FAR PASCAL MDriveCreate (
  1439.                                      UINT nMemory
  1440.                                     )
  1441.  
  1442.  Creates a MDrive object associated with identifier nMemory and
  1443.  returns a pointer to it.
  1444.  
  1445.  Example:
  1446.          VOID far *pDriveA ;
  1447.  
  1448.          pDriveA = MDriveCreate ( 1 ) ;
  1449. >>MDriveDelete
  1450. ------------------ SABDU001.DLL API: MDriveDelete --------------------
  1451.  
  1452.  VOID       FAR PASCAL MDriveDelete (
  1453.                                      pMDrive
  1454.                                     )
  1455.  
  1456.  Deletes the MDrive object pointed to by pMDrive.
  1457.  
  1458.  Example:
  1459.          VOID far *pDriveA ;
  1460.  
  1461.          pDriveA = MDriveCreate ( 'A' ) ;
  1462.          ...
  1463.          MDriveDelete ( pDriveA ) ;
  1464.          pDriveA = NULL ;
  1465. >>MDriveSetRead
  1466. ------------------ SABDU001.DLL API: MDriveSetRead -------------------
  1467.  
  1468.  UINT       FAR PASCAL MDriveSetRead (
  1469.                                       VOID far *pMDrive,
  1470.                                       UINT nTempType,
  1471.                                       UINT nCylinders
  1472.                                      )
  1473.  
  1474.  Prepares the MDrive object pointed to by pMDrive for reading.
  1475.  
  1476.  nTempType defines the type of diskette expected:
  1477.            FD0360 FD0720 FD1200 FD1440 FD2880
  1478.  
  1479.  nCylinders defines the number of cylinders.
  1480.  
  1481.  Example:
  1482.          VOID far *pDriveA ;
  1483.  
  1484.          pDriveA = MDriveCreate ( 'A' ) ;
  1485.          ...
  1486.          MDriveSetRead ( pDriveA, FD0360, NULL ) ;
  1487. >>MDriveSetWrite
  1488. ------------------ SABDU001.DLL API: MDriveSetWrite ------------------
  1489.  
  1490.  UINT       FAR PASCAL MDriveSetWrite (
  1491.                                        VOID far *pMDrive,
  1492.                                        UINT nTempType,
  1493.                                        UINT nCylinders
  1494.                                       )
  1495.  
  1496.  Prepares the MDrive object pointed to by pMDrive for writing.
  1497.  
  1498.  nTempType defines the type of diskette expected:
  1499.            FD0360 FD0720 FD1200 FD1440 FD2880
  1500.  
  1501.  nCylinders defines the number of cylinders.
  1502.  
  1503.  Example:
  1504.          VOID far *pDriveA ;
  1505.  
  1506.          pDriveA = MDriveCreate ( 'A' ) ;
  1507.          ...
  1508.          MDriveSetWrite ( pDriveA, FD0360, NULL ) ;
  1509. >>MDriveReset
  1510. ------------------ SABDU001.DLL API: MDriveReset ---------------------
  1511.  
  1512.  UINT       FAR PASCAL MDriveReset (
  1513.                                     VOID far *pMDrive
  1514.                                    )
  1515.  
  1516.  Resets the MDrive object pointed to by pMDrive.
  1517.  
  1518.  Example:
  1519.          VOID far *pDriveA ;
  1520.  
  1521.          pDriveA = MDriveCreate ( 'A' ) ;
  1522.          ...
  1523.          MDriveReset ( pDriveA ) ;
  1524. >>MDriveForceReset
  1525. ------------------ SABDU001.DLL API: MDriveForceReset ----------------
  1526.  
  1527.  UINT       FAR PASCAL MDriveForceReset (
  1528.                                          VOID far *pMDrive
  1529.                                         )
  1530.  
  1531.  Resets the MDrive object pointed to by pMDrive.
  1532.  
  1533.  Example:
  1534.          VOID far *pDriveA ;
  1535.  
  1536.          pDriveA = MDriveCreate ( 'A' ) ;
  1537.          ...
  1538.          MDriveForceReset ( pDriveA ) ;
  1539. >>MDriveFormatTrack
  1540. ------------------ SABDU001.DLL API: MDriveFormatTrack ---------------
  1541.  
  1542.  UINT       FAR PASCAL MDriveForceReset (
  1543.                                          VOID far *pMDrive,
  1544.                                          UNIT nCylinder,
  1545.                                          UNIT nHead
  1546.                                         )
  1547.  
  1548.  Formats the track pointed to by MDrive object pointer
  1549.  
  1550.  Example:
  1551.          VOID far *pDriveA ;
  1552.  
  1553.          pDriveA = MDriveCreate ( pDriveA ) ;
  1554.          ...
  1555.          MDriveFormatTrack ( pDriveA, nCylinder, nHead ) ;
  1556. >>MDriveReadSectors
  1557. ------------------ SABDU001.DLL API: MDriveReadSectors ---------------
  1558.  
  1559.  UINT       FAR PASCAL MDriveReadSectors (
  1560.                                           VOID far *pMDrive,
  1561.                                           UNIT nCylinder,
  1562.                                           UNIT nHead,
  1563.                                           UINT nSector,
  1564.                                           UINT nCount,
  1565.                                           LPBYTE lpcBuffer
  1566.                                          )
  1567.  
  1568.  Reads a group of sectors from the drive pointerd to by pMDrive
  1569.  
  1570.  nCylinder     Cylinder to read from
  1571.  nHead         Head to read with
  1572.  nSector       Starting sector
  1573.  nCount        Number of sectors to read
  1574.  lpcBuffer     Buffer to contain the data read.
  1575.  
  1576.  Example:
  1577.          VOID far *pDriveA ;
  1578.  
  1579.          pDriveA = MDriveCreate ( pDriveA ) ;
  1580.          ...
  1581.          MDriveReadSectors ( pDriveA, nCylinder, nHead, nSector,
  1582.                              nCount, lpcBuffer ) ;
  1583. >>MDriveWriteSectors
  1584. ------------------ SABDU001.DLL API: MDriveWriteSectors --------------
  1585.  
  1586.  UINT       FAR PASCAL MDriveWriteSectors (
  1587.                                            VOID far *pMDrive,
  1588.                                            UNIT nCylinder,
  1589.                                            UNIT nHead,
  1590.                                            UINT nSector,
  1591.                                            UINT nCount,
  1592.                                            LPBYTE lpcBuffer
  1593.                                           )
  1594.  
  1595.  Writes a group of sectors from the drive pointerd to by pMDrive
  1596.  
  1597.  nCylinder     Cylinder to read from
  1598.  nHead         Head to read with
  1599.  nSector       Starting sector
  1600.  nCount        Number of sectors to read
  1601.  lpcBuffer     Buffer to contain the data read.
  1602.  
  1603.  Example:
  1604.          VOID far *pDriveA ;
  1605.  
  1606.          pDriveA = MDriveCreate ( pDriveA ) ;
  1607.          ...
  1608.          MDriveWriteSectors ( pDriveA, nCylinder, nHead, nSector,
  1609.                               nCount, lpcBuffer ) ;
  1610. >>VDrive
  1611. ------------------ SABDU001.DLL API: VDrive objects ------------------
  1612.  
  1613.  A VDrive (Virtual Drive) is an object that represents a diskette
  1614.  image.
  1615.  
  1616.  The following functions are available to manipulate it:
  1617.      VDriveFlag              Returns the flags for the virtual drive
  1618.      VDriveForceReset        Forces a reset of the virtual drive
  1619.      VDriveFormatTrack       Formats a track
  1620.      VDriveIsRemote          Returns TRUE if media is remote
  1621.      VDriveIsRemovable       Returns TRUE if media is removable
  1622.      VDriveIsUseable         Returns TRUE if media is useable
  1623.      VDriveIsUsed            Returns TRUE if virtual drive was used
  1624.      VDriveLetter            Returns letter of vitual drive
  1625.      VDriveNumberOfCylinders Returns number of cylinders
  1626.      VDriveNumberOfHeads     Returns number of heads
  1627.      VDriveNumberOfSectors   Returns number of sectors
  1628.      VDriveReadSectors       Reads a group of sectors from the vitual drive
  1629.      VDriveReset             Resets the virtual drive if it was used
  1630.      VDriveSetRead           Sets up the virtual drive for reading
  1631.      VDriveSetType           Sets the type (density) of the virtual drive
  1632.      VDriveSetWrite          Sets up the virtual drive for writing
  1633.      VDriveType              Returns the type (density) of the virtual drive
  1634.      VDriveWriteSectors      Writes a group of sectors to the virutal drive
  1635. >>VDriveSetType
  1636. ------------------ SABDU001.DLL API: VDriveSetType -------------------
  1637.  
  1638.  UINT FAR PASCAL VDriveSetType (
  1639.                                 VOID far *pCVDrive,
  1640.                                 UINT nType
  1641.                                )
  1642.  
  1643.  Sets the type (density) for the virtual drive.
  1644.       nType = FD0360
  1645.               FD0720
  1646.               FD1200
  1647.               FD1200H
  1648.               FD1440
  1649.               FD1440H
  1650.               FD2880
  1651.  
  1652.  Returns nType if successfull or FD0000 if not.
  1653.  
  1654.  Example:
  1655.          VOID far *pDriveA ;
  1656.  
  1657.          VDriveSetType ( pDriveA, FD0720 ) ;
  1658. >>VDriveLetter
  1659. ------------------ SABDU001.DLL API: VDriveLetter --------------------
  1660.  
  1661.  char FAR PASCAL VDriveLetter (
  1662.                                VOID far *pCVDrive
  1663.                               )
  1664.  
  1665.  Returns the drive letter.
  1666.  
  1667.  Example:
  1668.          VOID far *pDriveA ;
  1669.          char cDrive ;
  1670.  
  1671.          cDrive = VDriveLetter ( pDriveA ) ;
  1672. >>VDriveType
  1673. ------------------ SABDU001.DLL API: VDriveType ----------------------
  1674.  
  1675.  UINT FAR PASCAL VDriveType (
  1676.                              VOID far *pCVDrive
  1677.                             )
  1678.  
  1679.  Returns the drive type (density).
  1680.  
  1681.  Example:
  1682.          VOID far *pDriveA ;
  1683.          UINT nType ;
  1684.  
  1685.          nType = VDriveType ( pDriveA ) ;
  1686. >>VDriveFlag
  1687. ------------------ SABDU001.DLL API: VDriveFlag ----------------------
  1688.  
  1689.  UINT FAR PASCAL VDriveFlag (
  1690.                              VOID far *pCVDrive
  1691.                             )
  1692.  
  1693.  Returns the drive flag.
  1694.  
  1695.  Example:
  1696.          VOID far *pDriveA ;
  1697.          UINT nFlag ;
  1698.  
  1699.          nFlag = VDriveFlag ( pDriveA ) ;
  1700. >>VDriveNumberOfCylinders
  1701. ------------------ SABDU001.DLL API: VDriveNumberOfCylinders ---------
  1702.  
  1703.  UINT FAR PASCAL VDriveNumberOfCylinders (
  1704.                                           VOID far *pCVDrive
  1705.                                          )
  1706.  
  1707.  Returns the number of cylinders.
  1708.  
  1709.  Example:
  1710.          VOID far *pDriveA ;
  1711.          UINT nCylinders ;
  1712.  
  1713.          nCylinders = VDriveNumberOfCylinders ( pDriveA ) ;
  1714. >>VDriveNumberOfHeads
  1715. ------------------ SABDU001.DLL API: VDriveNumberOfHeads -------------
  1716.  
  1717.  UINT FAR PASCAL VDriveNumberOfHeads (
  1718.                                       VOID far *pCVDrive
  1719.                                      )
  1720.  
  1721.  Returns the number of heads.
  1722.  
  1723.  Example:
  1724.          VOID far *pDriveA ;
  1725.          UINT nHeads ;
  1726.  
  1727.          nHeads = VDriveNumberOfHeads ( pDriveA ) ;
  1728. >>VDriveNumberOfSectors
  1729. ------------------ SABDU001.DLL API: VDriveNumberOfSectors -----------
  1730.  
  1731.  UINT FAR PASCAL VDriveNumberOfSectors (
  1732.                                         VOID far *pCVDrive
  1733.                                        )
  1734.  
  1735.  Returns the number of sectors.
  1736.  
  1737.  Example:
  1738.          VOID far *pDriveA ;
  1739.          UINT nSectors ;
  1740.  
  1741.          nSectors = VDriveNumberOfSectors ( pDriveA ) ;
  1742. >>VDriveIsRemote
  1743. ------------------ SABDU001.DLL API: VDriveIsRemote ------------------
  1744.  
  1745.  BOOL FAR PASCAL VDriveIsRemote (
  1746.                                  VOID far *pCVDrive
  1747.                                 )
  1748.  
  1749.  Returns TRUE if the media is remote.
  1750.  
  1751.  Example:
  1752.          VOID far *pDriveA ;
  1753.          BOOL bRemote ;
  1754.  
  1755.          bRemote = VDriveIsRemote ( pDriveA ) ;
  1756. >>VDriveIsRemovable
  1757. ------------------ SABDU001.DLL API: VDriveIsRemovable ---------------
  1758.  
  1759.  BOOL FAR PASCAL VDriveIsRemovable (
  1760.                                     VOID far *pCVDrive
  1761.                                    )
  1762.  
  1763.  Returns TRUE if the media is removable.
  1764.  
  1765.  Example:
  1766.          VOID far *pDriveA ;
  1767.          BOOL bRemovable ;
  1768.  
  1769.          bRemovable = VDriveIsRemovable ( pDriveA ) ;
  1770. >>VDriveIsUseable
  1771. ------------------ SABDU001.DLL API: VDriveIsUseable -----------------
  1772.  
  1773.  BOOL FAR PASCAL VDriveIsUseable (
  1774.                                   VOID far *pCVDrive
  1775.                                  )
  1776.  
  1777.  Returns TRUE if the media is useable.
  1778.  
  1779.  Example:
  1780.          VOID far *pDriveA ;
  1781.          BOOL bUseable ;
  1782.  
  1783.          bUseable = VDriveIsUseable ( pDriveA ) ;
  1784. >>VDriveIsUsed
  1785. ------------------ SABDU001.DLL API: VDriveIsUsed --------------------
  1786.  
  1787.  BOOL FAR PASCAL VDriveIsUsead (
  1788.                                 VOID far *pCVDrive
  1789.                                )
  1790.  
  1791.  Returns TRUE if the media is used.
  1792.  
  1793.  Example:
  1794.          VOID far *pDriveA ;
  1795.          BOOL bUsed ;
  1796.  
  1797.          bUsed = VDriveIsUsed ( pDriveA ) ;
  1798. >>VDriveReset
  1799. ------------------ SABDU001.DLL API: VDriveReset ---------------------
  1800.  
  1801.  UINT FAR PASCAL VDriveReset (
  1802.                               VOID far *pCVDrive
  1803.                              )
  1804.  
  1805.  Returns FALSE if successfull.
  1806.  
  1807.  Example:
  1808.          VOID far *pDriveA ;
  1809.          BOOL bReset ;
  1810.  
  1811.          bReset = !VDriveReset ( pDriveA ) ;
  1812. >>VDriveFormatTrack
  1813. ------------------ SABDU001.DLL API: VDriveFormatTrack ---------------
  1814.  
  1815.  UINT FAR PASCAL VDriveFormatTrack (
  1816.                                     VOID far *pCVDrive,
  1817.                                     UINT nCylinder,
  1818.                                     UINT nHead
  1819.                                    )
  1820.  
  1821.  Returns FALSE if successfull.
  1822.  
  1823.  Example:
  1824.          VOID far *pDriveA ;
  1825.          BOOL bFormat ;
  1826.  
  1827.          bReset = !VDriveFormatTrack ( pDriveA, nCylinder, nHead ) ;
  1828. >>VDriveReadSectors
  1829. ------------------ SABDU001.DLL API: VDriveReadSectors ---------------
  1830.  
  1831.  UINT FAR PASCAL VDriveReadSectors (
  1832.                                     VOID far *pCVDrive,
  1833.                                     UINT nCylinder,
  1834.                                     UINT nHead
  1835.                                    )
  1836.  
  1837.  Returns FALSE if successfull.
  1838.  
  1839.  Example:
  1840.          VOID far *pDriveA ;
  1841.          BOOL bRead ;
  1842.  
  1843.          bRead = !VDriveReadSectors ( pDriveA, nCylinder, nHead,
  1844.                                       nSector, nCount, LPBYTE lpcBuffer ) ;
  1845. >>VDriveWriteSectors
  1846. ------------------ SABDU001.DLL API: VDriveWriteSectors --------------
  1847.  
  1848.  UINT FAR PASCAL VDriveWriteSectors (
  1849.                                      VOID far *pCVDrive,
  1850.                                      UINT nCylinder,
  1851.                                      UINT nHead
  1852.                                     )
  1853.  
  1854.  Returns FALSE if successfull.
  1855.  
  1856.  Example:
  1857.          VOID far *pDriveA ;
  1858.          BOOL bWrite ;
  1859.  
  1860.          bWrite = !VDriveWriteSectors ( pDriveA, nCylinder, nHead,
  1861.                               nSector, nCount, LPBYTE lpcBuffer ) ;
  1862.